An assembler and disassembler framework for Java™ programmers

AbstractThe Java™ programming language is primarily used for platform-independent programming. Yet it also offers many productivity, maintainability and performance benefits for platform-specific functions, such as the generation of machine code.We have created reliable assemblers for SPARC™ , AMD64, IA32 and PowerPC which support all user mode and privileged instructions and with 64 bit mode support for all but the latter. These assemblers are generated as Java source code by our extensible assembler framework, which itself is written in the Java language. The assembler generator also produces javadoc comments that precisely specify the legal values for each operand.Our design is based on the Klein Assembler System written in Self. Assemblers are generated from a specification, as are table-driven disassemblers and unit tests. The specifications that drive the generators are expressed as Java language objects. Thus no extra parsers are needed and developers do not need to learn any new syntax to extend the framework for additional ISAs.Every generated assembler is tested against a preexisting assembler by comparing the output of both. Each instruction’s test cases are derived from the cross product of its potential operand values. The majority of tests are positive (i.e., result in a legal instruction encoding). The framework also generates negative tests, which are expected to cause an error detection by an assembler. As with the Klein Assembler System, we have found bugs in the external assemblers as well as in ISA reference manuals.Our framework generates tens of millions of tests. For symbolic operands, our tests include all applicable predefined constants. For integral operands, the important boundary values, such as the respective minimum, maximum, 0, 1 and −1, are tested. Full testing can take hours to run but gives us a high degree of confidence regarding correctness

\Simplicity, Performance and Portability in Virtual Machine Design",

We implemented orthogonal persistence for the Java platform by adding persistent object caching to a high-performance virtual machine that uses exact garbage collection (\EVM") 1. This paper gives an overview of our design for the read and write barriers needed to support persistence. The key design decision we made was the choice of a pointer swizzling strategy. Pointer swizzling speeds up programs by translating persistent addresses (references to persistent objects on disk) into normal virtual memory addresses in the object cache. The swizzling technique we chose is simple (requires few source changes to the EVM) and performs well (adds acceptably low CPU overhead to the EVM). Our integration of the new barriers was considerably simpli ed by aninternal memory interface that the EVM consistently uses, except in its JIT, to access program runtime values. Our new persistent version of the EVM, the PEVM, requires just 30 % of the changes necessary in our previous persistent virtual machine implementations. It executes programs with only modest runtime overhead (typically 10-20%) compared to an unchanged EVM. Java, Sun, Sun Microsystems are trademarks or registered trademarks of Sun Microsystems, Inc. in the United States and other countries. All SPARC trademarks are used under license and are trademarks or registered trademarks of SPARC International, Inc. in the United States and other countries. Products bearing SPARC trademarks are based upon an architecture developed by Sun Microsystems, Inc. 1 An EVM is embedded in Sun's Java TM 2 SDK Production Release for the Solaris TM Operating Environment, available a

Scaling Database Languages to Higher-Order Distributed Programming

We describe the Tycoon approach to scale the successful notion of a uniform, type-safe persistent object store to communication-intensive applications and applications where long-term activities are allowed to span multiple autonomous network sites. Exploiting stream-based data, code and thread exchange primitives we present several distributed programming idioms in Tycoon. These programming patterns range from client-server communication based on polymorphic higher-order remote procedure calls to migrating autonomous agents that are bound dynamically to network resources present at individual network nodes. Following Tycoon's add-on approach, these idioms are not cast into built-in syntactic forms, but are expressed by characteristic programming patterns exploiting communication primitives encapsulated by library functions. Moreover, we present a novel form of binding support for ubiquitous resources which drastically reduces communication traffic for modular distributed applications.

Scaling Database Languages to Higher-Order Distributed Programming

©Copyright in this paper belongs to the author(s) Published in collaboration with th

On Migrating Threads

Based on the notion of persistent threads in Tycoon [MS94], we investigate thread migration as a programming construct for building activity-oriented distributed applications. We first show how a straight-forward extension of a higher-order persistent language can be used to define activities that span multiple (semi-) autonomous nodes in heterogeneous networks. In particular, we discuss the intricate binding issues that arise in systems where threads are first-class language citizens that may access local and remote, mobile and immobile resources. We also describe how our system model can be understood as a promising generalization of the more static architecture of first-order and higher-order distributed object systems. Finally, we give some insight into the implementation of persistent and migrating threads and we explain how to represent bindings to ubiquitous resources present at each node visited by a migrating thread on the network to avoid excessive communication or storag..

Abstract Automatic Persistent Memory Management for the Spotless Java TM Virtual Machine on the Palm Connected Organizer ∗

Palm organizers are widely used in a multi-tasking fashion. Users switch from one application to another without losing the context established in either of them. Despite its obvious usefulness there is no automatic support for this convenience in the organizer’s operating system, PalmOS. Programmers must implement event callbacks that use the PalmOS database API to save and reload specific application state. In this report we describe how this burden can be eliminated. We enhanced the Spotless Java TM virtual machine for the Palm organizer with transparent multitasking support that automates persistence. As a consequence, running Java programs can be transfered between two Palm organizers using the infra-red link. A transfered program will resume on the receiving organizer in the exact same state as it had on the sender. In addition, a HotSync operation can effectively be used to establish a checkpoint for each Java program involved. Originally, the address range available for running ∗ TRADEMARKS Sun, Sun Microsystems, the Sun logo, and Java are trademarks or registered trademarks of Sun Microsystems, Inc. in the U.S. and other countries. All SPARC trademarks are used under license and are trademarks or registere